home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 2002 November / SGI Freeware 2002 November - Disc 2.iso / dist / fw_guile.idb / usr / freeware / include / guile / gh.h.z / gh.h
Encoding:
C/C++ Source or Header  |  2002-07-08  |  9.3 KB  |  262 lines
  1. /* Copyright (C) 1995,1996,1997,1998,2000,2001 Free Software Foundation, Inc.
  2.  * 
  3.  * This program is free software; you can redistribute it and/or modify
  4.  * it under the terms of the GNU General Public License as published by
  5.  * the Free Software Foundation; either version 2, or (at your option)
  6.  * any later version.
  7.  * 
  8.  * This program is distributed in the hope that it will be useful,
  9.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.  * GNU General Public License for more details.
  12.  * 
  13.  * You should have received a copy of the GNU General Public License
  14.  * along with this software; see the file COPYING.  If not, write to
  15.  * the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  16.  * Boston, MA 02111-1307 USA
  17.  *
  18.  * As a special exception, the Free Software Foundation gives permission
  19.  * for additional uses of the text contained in its release of GUILE.
  20.  *
  21.  * The exception is that, if you link the GUILE library with other files
  22.  * to produce an executable, this does not by itself cause the
  23.  * resulting executable to be covered by the GNU General Public License.
  24.  * Your use of that executable is in no way restricted on account of
  25.  * linking the GUILE library code into it.
  26.  *
  27.  * This exception does not however invalidate any other reasons why
  28.  * the executable file might be covered by the GNU General Public License.
  29.  *
  30.  * This exception applies only to the code released by the
  31.  * Free Software Foundation under the name GUILE.  If you copy
  32.  * code from other Free Software Foundation releases into a copy of
  33.  * GUILE, as the General Public License permits, the exception does
  34.  * not apply to the code that you add in this way.  To avoid misleading
  35.  * anyone as to the status of such modified files, you must delete
  36.  * this exception notice from them.
  37.  *
  38.  * If you write modifications of your own for GUILE, it is your choice
  39.  * whether to permit this exception to apply to your modifications.
  40.  * If you do not wish that, delete this exception notice.  */
  41.  
  42.  
  43. #ifndef __GH_H
  44. #define __GH_H
  45.  
  46. #ifdef __cplusplus
  47. extern "C" {
  48. #endif
  49.  
  50. #include <libguile.h>
  51.  
  52. /* gcc has extern inline functions that are basically as fast as macros */
  53. #ifdef __GNUC__
  54. # define INL inline
  55. # define EXTINL extern inline
  56. #else
  57. # define INL
  58. #define EXTINL
  59. #endif /* __GNUC__ */
  60.  
  61. void gh_enter(int argc, char *argv[], void (*c_main_prog)(int, char **));
  62. #define gh_init () scm_init_guile ()
  63. void gh_repl(int argc, char *argv[]);
  64. SCM gh_catch(SCM tag, scm_t_catch_body body, void *body_data,
  65.          scm_t_catch_handler handler, void *handler_data);
  66.  
  67. SCM gh_standard_handler(void *data, SCM tag, SCM throw_args);
  68.  
  69. SCM gh_eval_str(const char *scheme_code);
  70. SCM gh_eval_str_with_catch(const char *scheme_code, scm_t_catch_handler handler);
  71. SCM gh_eval_str_with_standard_handler(const char *scheme_code);
  72. SCM gh_eval_str_with_stack_saving_handler(const char *scheme_code);
  73.  
  74. SCM gh_eval_file(const char *fname);
  75. #define gh_load(fname) gh_eval_file(fname)
  76. SCM gh_eval_file_with_catch(const char *scheme_code, scm_t_catch_handler handler);
  77. SCM gh_eval_file_with_standard_handler(const char *scheme_code);
  78.  
  79. #define gh_defer_ints() SCM_DEFER_INTS
  80. #define gh_allow_ints() SCM_ALLOW_INTS
  81.  
  82. SCM gh_new_procedure(const char *proc_name, SCM (*fn)(),
  83.              int n_required_args, int n_optional_args, int varp);
  84. SCM gh_new_procedure0_0(const char *proc_name, SCM (*fn)(void));
  85. SCM gh_new_procedure0_1(const char *proc_name, SCM (*fn)(SCM));
  86. SCM gh_new_procedure0_2(const char *proc_name, SCM (*fn)(SCM, SCM));
  87. SCM gh_new_procedure1_0(const char *proc_name, SCM (*fn)(SCM));
  88. SCM gh_new_procedure1_1(const char *proc_name, SCM (*fn)(SCM, SCM));
  89. SCM gh_new_procedure1_2(const char *proc_name, SCM (*fn)(SCM, SCM, SCM));
  90. SCM gh_new_procedure2_0(const char *proc_name, SCM (*fn)(SCM, SCM));
  91. SCM gh_new_procedure2_1(const char *proc_name, SCM (*fn)(SCM, SCM, SCM));
  92. SCM gh_new_procedure2_2(const char *proc_name, SCM (*fn)(SCM, SCM, SCM, SCM));
  93. SCM gh_new_procedure3_0(const char *proc_name, SCM (*fn)(SCM, SCM, SCM));
  94. SCM gh_new_procedure4_0(const char *proc_name, SCM (*fn)(SCM, SCM, SCM, SCM));
  95. SCM gh_new_procedure5_0(const char *proc_name, SCM (*fn)(SCM, SCM, SCM, SCM, SCM));
  96.  
  97. /* C to Scheme conversion */
  98. SCM gh_bool2scm(int x);
  99. SCM gh_int2scm(int x);
  100. SCM gh_ulong2scm(unsigned long x);
  101. SCM gh_long2scm(long x);
  102. SCM gh_double2scm(double x);
  103. SCM gh_char2scm(char c);
  104. SCM gh_str2scm(const char *s, size_t len);
  105. SCM gh_str02scm(const char *s);
  106. void gh_set_substr(char *src, SCM dst, long start, size_t len);
  107. SCM gh_symbol2scm(const char *symbol_str);
  108. SCM gh_ints2scm(const int *d, long n);
  109.  
  110. #ifdef HAVE_ARRAYS
  111. SCM gh_chars2byvect(const char *d, long n);
  112. SCM gh_shorts2svect(const short *d, long n);
  113. SCM gh_longs2ivect(const long *d, long n);
  114. SCM gh_ulongs2uvect(const unsigned long *d, long n);
  115. SCM gh_floats2fvect(const float *d, long n);
  116. SCM gh_doubles2dvect(const double *d, long n);
  117. #endif
  118.  
  119. SCM gh_doubles2scm(const double *d, long n);
  120.  
  121. /* Scheme to C conversion */
  122. int gh_scm2bool(SCM obj);
  123. int gh_scm2int(SCM obj);
  124. unsigned long gh_scm2ulong(SCM obj);
  125. long gh_scm2long(SCM obj);
  126. char gh_scm2char(SCM obj);
  127. double gh_scm2double(SCM obj);
  128. char *gh_scm2newstr(SCM str, size_t *lenp);
  129. void gh_get_substr(SCM src, char *dst, long start, size_t len);
  130. char *gh_symbol2newstr(SCM sym, size_t *lenp);
  131. char *gh_scm2chars(SCM vector, char *result);
  132. short *gh_scm2shorts(SCM vector, short *result);
  133. long *gh_scm2longs(SCM vector, long *result);
  134. float *gh_scm2floats(SCM vector, float *result);
  135. double *gh_scm2doubles(SCM vector, double *result);
  136.  
  137. /* type predicates: tell you if an SCM object has a given type */
  138. int gh_boolean_p(SCM val);
  139. int gh_symbol_p(SCM val);
  140. int gh_char_p(SCM val);
  141. int gh_vector_p(SCM val);
  142. int gh_pair_p(SCM val);
  143. int gh_number_p(SCM val);
  144. int gh_string_p(SCM val);
  145. int gh_procedure_p(SCM val);
  146. int gh_list_p(SCM val);
  147. int gh_inexact_p(SCM val);
  148. int gh_exact_p(SCM val);
  149.  
  150. /* more predicates */
  151. int gh_eq_p(SCM x, SCM y);
  152. int gh_eqv_p(SCM x, SCM y);
  153. int gh_equal_p(SCM x, SCM y);
  154. int gh_string_equal_p(SCM s1, SCM s2);
  155. int gh_null_p(SCM l);
  156.  
  157. /* standard Scheme procedures available from C */
  158.  
  159. #define gh_not(x) scm_not(x)
  160.  
  161. SCM gh_define(const char *name, SCM val);
  162.  
  163. /* string manipulation routines */
  164. #define gh_make_string(k, chr)       scm_make_string(k, chr)
  165. #define gh_string_length(str)        scm_string_length(str)
  166. #define gh_string_ref(str, k)        scm_string_ref(str, k)
  167. #define gh_string_set_x(str, k, chr) scm_string_set_x(str, k, chr)
  168. #define gh_substring(str, start,end) scm_substring(str, start, end)
  169. #define gh_string_append(args)       scm_string_append(args)
  170.  
  171.  
  172. /* vector manipulation routines */
  173. /* note that gh_vector() does not behave quite like the Scheme (vector
  174.    obj1 obj2 ...), because the interpreter engine does not pass the
  175.    data element by element, but rather as a list.  thus, gh_vector()
  176.    ends up being identical to gh_list_to_vector() */
  177. #define gh_vector(ls) scm_vector(ls)
  178. SCM gh_make_vector(SCM length, SCM val);
  179. SCM gh_vector_set_x(SCM vec, SCM pos, SCM val);
  180. SCM gh_vector_ref(SCM vec, SCM pos);
  181. unsigned long gh_vector_length (SCM v);
  182. unsigned long gh_uniform_vector_length (SCM v);
  183. SCM gh_uniform_vector_ref (SCM v, SCM ilist);
  184. #define gh_list_to_vector(ls) scm_vector(ls)
  185. #define gh_vector_to_list(v) scm_vector_to_list(v)
  186.  
  187. SCM gh_lookup (const char *sname);
  188. SCM gh_module_lookup (SCM module, const char *sname);
  189.  
  190. SCM gh_cons(SCM x, SCM y);
  191. #define gh_list scm_list_n
  192. unsigned long gh_length(SCM l);
  193. SCM gh_append(SCM args);
  194. SCM gh_append2(SCM l1, SCM l2);
  195. SCM gh_append3(SCM l1, SCM l2, SCM l3);
  196. SCM gh_append4(SCM l1, SCM l2, SCM l3, SCM l4);
  197. #define gh_reverse(ls) scm_reverse(ls)
  198. #define gh_list_tail(ls, k) scm_list_tail(ls, k)
  199. #define gh_list_ref(ls, k) scm_list_ref(ls, k)
  200. #define gh_memq(x, ls) scm_memq(x, ls)
  201. #define gh_memv(x, ls) scm_memv(x, ls)
  202. #define gh_member(x, ls) scm_member(x, ls)
  203. #define gh_assq(x, alist) scm_assq(x, alist)
  204. #define gh_assv(x, alist) scm_assv(x, alist)
  205. #define gh_assoc(x, alist) scm_assoc(x, alist)
  206.  
  207. SCM gh_car(SCM x);
  208. SCM gh_cdr(SCM x);
  209.  
  210. SCM gh_caar(SCM x);
  211. SCM gh_cadr(SCM x);
  212. SCM gh_cdar(SCM x);
  213. SCM gh_cddr(SCM x);
  214.  
  215. SCM gh_caaar(SCM x);
  216. SCM gh_caadr(SCM x);
  217. SCM gh_cadar(SCM x);
  218. SCM gh_caddr(SCM x);
  219. SCM gh_cdaar(SCM x);
  220. SCM gh_cdadr(SCM x);
  221. SCM gh_cddar(SCM x);
  222. SCM gh_cdddr(SCM x);
  223.  
  224. SCM gh_set_car_x(SCM pair, SCM value);
  225. SCM gh_set_cdr_x(SCM pair, SCM value);
  226.  
  227.  
  228. /* Calling Scheme functions from C.  */
  229. SCM gh_apply (SCM proc, SCM ls);
  230. SCM gh_call0 (SCM proc);
  231. SCM gh_call1 (SCM proc, SCM arg);
  232. SCM gh_call2 (SCM proc, SCM arg1, SCM arg2);
  233. SCM gh_call3 (SCM proc, SCM arg1, SCM arg2, SCM arg3);
  234.  
  235. /* reading and writing Scheme objects.  */
  236. void gh_display (SCM x);
  237. void gh_write (SCM x);
  238. void gh_newline (void);
  239.  
  240. /* void  gh_gc_mark(SCM)              : mark an SCM as in use. */
  241. /* void  gh_defer_ints()              : don't interrupt code section. */
  242. /* void  gh_allow_ints()              : see gh_defer_ints(). */
  243. /* void  gh_new_cell(SCM, int tag)    : initialize SCM to be of type 'tag' */
  244. /* int   gh_type_p(SCM, tag)          : test if SCM is of type 'tag' */
  245. /* SCM   gh_intern(char*)             : get symbol corresponding to c-string.*/
  246. /* void  gh_set_ext_data(SCM, void*)  : set extension data on SCM */
  247. /* void *gh_get_ext_data(SCM)         : return extension data from SCM. */
  248.  
  249. /* void  gh_assert(int cond, char *msg, SCM obj); */
  250.  
  251. #ifdef __cplusplus
  252. }
  253. #endif
  254.  
  255. #endif /* __GH_H */
  256.  
  257. /*
  258.   Local Variables:
  259.   c-file-style: "gnu"
  260.   End:
  261. */
  262.